home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / logging / config.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  8.1 KB  |  301 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """
  5. Configuration functions for the logging package for Python. The core package
  6. is based on PEP 282 and comments thereto in comp.lang.python, and influenced
  7. by Apache's log4j system.
  8.  
  9. Should work under Python versions >= 1.5.2, except that source line
  10. information is not available unless 'sys._getframe()' is.
  11.  
  12. Copyright (C) 2001-2004 Vinay Sajip. All Rights Reserved.
  13.  
  14. To use, simply 'import logging' and log away!
  15. """
  16. import sys
  17. import logging
  18. import logging.handlers as logging
  19. import string
  20. import socket
  21. import struct
  22. import os
  23. import traceback
  24.  
  25. try:
  26.     import thread
  27.     import threading
  28. except ImportError:
  29.     thread = None
  30.  
  31. from SocketServer import ThreadingTCPServer, StreamRequestHandler
  32. DEFAULT_LOGGING_CONFIG_PORT = 9030
  33. if sys.platform == 'win32':
  34.     RESET_ERROR = 10054
  35. else:
  36.     RESET_ERROR = 104
  37. _listener = None
  38.  
  39. def fileConfig(fname, defaults = None):
  40.     '''
  41.     Read the logging configuration from a ConfigParser-format file.
  42.  
  43.     This can be called several times from an application, allowing an end user
  44.     the ability to select from various pre-canned configurations (if the
  45.     developer provides a mechanism to present the choices and load the chosen
  46.     configuration).
  47.     In versions of ConfigParser which have the readfp method [typically
  48.     shipped in 2.x versions of Python], you can pass in a file-like object
  49.     rather than a filename, in which case the file-like object will be read
  50.     using readfp.
  51.     '''
  52.     import ConfigParser
  53.     cp = ConfigParser.ConfigParser(defaults)
  54.     if hasattr(cp, 'readfp') and hasattr(fname, 'readline'):
  55.         cp.readfp(fname)
  56.     else:
  57.         cp.read(fname)
  58.     flist = cp.get('formatters', 'keys')
  59.     if len(flist):
  60.         flist = string.split(flist, ',')
  61.         formatters = { }
  62.         for form in flist:
  63.             sectname = 'formatter_%s' % form
  64.             opts = cp.options(sectname)
  65.             if 'format' in opts:
  66.                 fs = cp.get(sectname, 'format', 1)
  67.             else:
  68.                 fs = None
  69.             if 'datefmt' in opts:
  70.                 dfs = cp.get(sectname, 'datefmt', 1)
  71.             else:
  72.                 dfs = None
  73.             f = logging.Formatter(fs, dfs)
  74.             formatters[form] = f
  75.         
  76.     
  77.     logging._acquireLock()
  78.     
  79.     try:
  80.         logging._handlers.clear()
  81.         hlist = cp.get('handlers', 'keys')
  82.         if len(hlist):
  83.             hlist = string.split(hlist, ',')
  84.             handlers = { }
  85.             fixups = []
  86.             for hand in hlist:
  87.                 
  88.                 try:
  89.                     sectname = 'handler_%s' % hand
  90.                     klass = cp.get(sectname, 'class')
  91.                     opts = cp.options(sectname)
  92.                     if 'formatter' in opts:
  93.                         fmt = cp.get(sectname, 'formatter')
  94.                     else:
  95.                         fmt = ''
  96.                     klass = eval(klass, vars(logging))
  97.                     args = cp.get(sectname, 'args')
  98.                     args = eval(args, vars(logging))
  99.                     h = apply(klass, args)
  100.                     if 'level' in opts:
  101.                         level = cp.get(sectname, 'level')
  102.                         h.setLevel(logging._levelNames[level])
  103.                     
  104.                     if len(fmt):
  105.                         h.setFormatter(formatters[fmt])
  106.                     
  107.                     if klass == logging.handlers.MemoryHandler:
  108.                         if 'target' in opts:
  109.                             target = cp.get(sectname, 'target')
  110.                         else:
  111.                             target = ''
  112.                         if len(target):
  113.                             fixups.append((h, target))
  114.                         
  115.                     
  116.                     handlers[hand] = h
  117.                 continue
  118.                 continue
  119.  
  120.             
  121.             for fixup in fixups:
  122.                 h = fixup[0]
  123.                 t = fixup[1]
  124.                 h.setTarget(handlers[t])
  125.             
  126.         
  127.         llist = cp.get('loggers', 'keys')
  128.         llist = string.split(llist, ',')
  129.         llist.remove('root')
  130.         sectname = 'logger_root'
  131.         root = logging.root
  132.         log = root
  133.         opts = cp.options(sectname)
  134.         if 'level' in opts:
  135.             level = cp.get(sectname, 'level')
  136.             log.setLevel(logging._levelNames[level])
  137.         
  138.         for h in root.handlers[:]:
  139.             root.removeHandler(h)
  140.         
  141.         hlist = cp.get(sectname, 'handlers')
  142.         if len(hlist):
  143.             hlist = string.split(hlist, ',')
  144.             for hand in hlist:
  145.                 log.addHandler(handlers[hand])
  146.             
  147.         
  148.         existing = root.manager.loggerDict.keys()
  149.         for log in llist:
  150.             sectname = 'logger_%s' % log
  151.             qn = cp.get(sectname, 'qualname')
  152.             opts = cp.options(sectname)
  153.             if 'propagate' in opts:
  154.                 propagate = cp.getint(sectname, 'propagate')
  155.             else:
  156.                 propagate = 1
  157.             logger = logging.getLogger(qn)
  158.             if qn in existing:
  159.                 existing.remove(qn)
  160.             
  161.             if 'level' in opts:
  162.                 level = cp.get(sectname, 'level')
  163.                 logger.setLevel(logging._levelNames[level])
  164.             
  165.             for h in logger.handlers[:]:
  166.                 logger.removeHandler(h)
  167.             
  168.             logger.propagate = propagate
  169.             logger.disabled = 0
  170.             hlist = cp.get(sectname, 'handlers')
  171.             if len(hlist):
  172.                 hlist = string.split(hlist, ',')
  173.                 for hand in hlist:
  174.                     logger.addHandler(handlers[hand])
  175.                 
  176.         
  177.         for log in existing:
  178.             root.manager.loggerDict[log].disabled = 1
  179.     except:
  180.         ei = sys.exc_info()
  181.         traceback.print_exception(ei[0], ei[1], ei[2], None, sys.stderr)
  182.         del ei
  183.     finally:
  184.         logging._releaseLock()
  185.  
  186.  
  187.  
  188. def listen(port = DEFAULT_LOGGING_CONFIG_PORT):
  189.     '''
  190.     Start up a socket server on the specified port, and listen for new
  191.     configurations.
  192.  
  193.     These will be sent as a file suitable for processing by fileConfig().
  194.     Returns a Thread object on which you can call start() to start the server,
  195.     and which you can join() when appropriate. To stop the server, call
  196.     stopListening().
  197.     '''
  198.     if not thread:
  199.         raise NotImplementedError, 'listen() needs threading to work'
  200.     
  201.     
  202.     class ConfigStreamHandler(StreamRequestHandler):
  203.         '''
  204.         Handler for a logging configuration request.
  205.  
  206.         It expects a completely new logging configuration and uses fileConfig
  207.         to install it.
  208.         '''
  209.         
  210.         def handle(self):
  211.             '''
  212.             Handle a request.
  213.  
  214.             Each request is expected to be a 4-byte length, packed using
  215.             struct.pack(">L", n), followed by the config file.
  216.             Uses fileConfig() to do the grunt work.
  217.             '''
  218.             import tempfile
  219.             
  220.             try:
  221.                 conn = self.connection
  222.                 chunk = conn.recv(4)
  223.                 if len(chunk) == 4:
  224.                     slen = struct.unpack('>L', chunk)[0]
  225.                     chunk = self.connection.recv(slen)
  226.                     while len(chunk) < slen:
  227.                         chunk = chunk + conn.recv(slen - len(chunk))
  228.                     file = tempfile.mktemp('.ini')
  229.                     f = open(file, 'w')
  230.                     f.write(chunk)
  231.                     f.close()
  232.                     fileConfig(file)
  233.                     os.remove(file)
  234.             except socket.error:
  235.                 e = None
  236.                 if type(e.args) != types.TupleType:
  237.                     raise 
  238.                 else:
  239.                     errcode = e.args[0]
  240.                     if errcode != RESET_ERROR:
  241.                         raise 
  242.                     
  243.             except:
  244.                 type(e.args) != types.TupleType
  245.  
  246.  
  247.  
  248.     
  249.     class ConfigSocketReceiver(ThreadingTCPServer):
  250.         '''
  251.         A simple TCP socket-based logging config receiver.
  252.         '''
  253.         allow_reuse_address = 1
  254.         
  255.         def __init__(self, host = 'localhost', port = DEFAULT_LOGGING_CONFIG_PORT, handler = None):
  256.             ThreadingTCPServer.__init__(self, (host, port), handler)
  257.             logging._acquireLock()
  258.             self.abort = 0
  259.             logging._releaseLock()
  260.             self.timeout = 1
  261.  
  262.         
  263.         def serve_until_stopped(self):
  264.             import select
  265.             abort = 0
  266.             while not abort:
  267.                 (rd, wr, ex) = select.select([
  268.                     self.socket.fileno()], [], [], self.timeout)
  269.                 if rd:
  270.                     self.handle_request()
  271.                 
  272.                 logging._acquireLock()
  273.                 abort = self.abort
  274.                 logging._releaseLock()
  275.  
  276.  
  277.     
  278.     def serve(rcvr, hdlr, port):
  279.         global _listener
  280.         server = rcvr(port = port, handler = hdlr)
  281.         logging._acquireLock()
  282.         _listener = server
  283.         logging._releaseLock()
  284.         server.serve_until_stopped()
  285.  
  286.     return threading.Thread(target = serve, args = (ConfigSocketReceiver, ConfigStreamHandler, port))
  287.  
  288.  
  289. def stopListening():
  290.     '''
  291.     Stop the listening server which was created with a call to listen().
  292.     '''
  293.     global _listener
  294.     if _listener:
  295.         logging._acquireLock()
  296.         _listener.abort = 1
  297.         _listener = None
  298.         logging._releaseLock()
  299.     
  300.  
  301.